/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.ec.socialfun.controladores;

import com.ec.socialfun.datamanager.AdministracionLocalDataManager;
import com.ec.socialfun.entidades.Ciudad;
import com.ec.socialfun.entidades.Evento;
import com.ec.socialfun.entidades.FormasDePago;
import com.ec.socialfun.entidades.Local;
import com.ec.socialfun.entidades.Pais;
import com.ec.socialfun.entidades.Sucursal;
import com.ec.socialfun.entidades.Usuario;
import com.ec.socialfun.entidades.Zona;
import com.ec.socialfun.enumeradores.CargaImagenesLocalEnum;
import com.ec.socialfun.enumeradores.DiaSemanaEnum;
import com.ec.socialfun.enumeradores.ParametrosEnum;
import com.ec.socialfun.excepciones.AdministracionLocalException;
import com.ec.socialfun.excepciones.CreaEventoException;
import com.ec.socialfun.excepciones.CreacionSucursalException;
import com.ec.socialfun.excepciones.CrearArchivoException;
import com.ec.socialfun.excepciones.CrearFormaDePagoException;
import com.ec.socialfun.excepciones.DescargarArchivoException;
import com.ec.socialfun.excepciones.ParametroException;
import com.ec.socialfun.servicios.EventoFacade;
import com.ec.socialfun.servicios.FormasDePagoFacade;
import com.ec.socialfun.servicios.LocalesFacade;
import com.ec.socialfun.servicios.LocalesFormasDePagoFacade;
import com.ec.socialfun.servicios.LocalesImagenFacade;
import com.ec.socialfun.servicios.ParametrosFacade;
import com.ec.socialfun.servicios.SucursalFacade;
import com.ec.socialfun.servicios.UsuarioFacade;
import com.ec.socialfun.servicios.externos.FtpServicio;
import com.ec.socialfun.util.AdministracionLocal;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.RequestScoped;
import javax.faces.model.SelectItem;
import org.jboss.logging.Logger;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.event.TabChangeEvent;

/**
 *
 * @author jorge
 */
@ManagedBean
@RequestScoped
public class AdministracionLocalControlador extends PadreControlador {

    private static final Logger LOG = Logger.getLogger(AdministracionLocalControlador.class.getName());
    @ManagedProperty(value = "#{administracionLocalDataManager}")
    private AdministracionLocalDataManager administracionLocalDataManager;
    @EJB
    private SucursalFacade sucursalFacade;
    @EJB
    private FormasDePagoFacade formasDePagoFacade;
    @EJB
    private LocalesFacade localFacade;
    @EJB
    private EventoFacade eventoFacade;
    @EJB
    private UsuarioFacade usuarioFacade;
    @EJB
    private FtpServicio ftpServicio;
    @EJB
    private LocalesImagenFacade localesImagenFacade;
    @EJB
    private ParametrosFacade parametrosFacade;
    @EJB
    private LocalesFormasDePagoFacade localesFormasDePagoFacade;
    private final String TAB_ADMINISTRACION_DATOS = "tabActualizacionDatosID";
    private final String TAB_SUCURSALES = "tabSucursalesID";
    private final String TAB_EVENTOS = "tabEventosID";
    private final String TAB_FOTOS = "tabFotosID";
    private final String TAB_HISTORIA = "tabHistoriaID";
    private List<String> listaComponentesCargaImagenes;
    private final String CARGA_IMAGEN_LOCAL_ID = "cargaImagenLocalID";
    private final String TAB_FORMAS_DE_PAGO = "tabFormasDePagoID";

    // Bloque de inicializacion
    {
        listaComponentesCargaImagenes = new ArrayList<String>();
        for (int i = 0; i < CargaImagenesLocalEnum.values().length; i++) {
            listaComponentesCargaImagenes.add(CargaImagenesLocalEnum.values()[i].getCodigo());
        }
    }

    /**
     * Creates a new instance of AdministracionLocalControlador
     */
    public AdministracionLocalControlador() {
    }

    @Override
    public void iniciarDatos() {
        List<Sucursal> listaSucursales = sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado());
        Local local = listaSucursales.iterator().next().getLoCodigo();
        AdministracionLocal admLocal = new AdministracionLocal();
        admLocal.setListaLocalesImagen(localesImagenFacade.recuperaPorLocal(local));
        admLocal.setListaSucursales(listaSucursales);
        admLocal.setLocal(local);
        getAdministracionLocalDataManager().setAdministracionLocal(admLocal);
        getAdministracionLocalDataManager().setCiudad(new Ciudad());
        getAdministracionLocalDataManager().setPais(new Pais());
        getAdministracionLocalDataManager().setSucursal(new Sucursal());
        getAdministracionLocalDataManager().setTabActivo(0);
        obtenerImagenLocal();

    }

    /**
     * Actualiza datos del local
     */
    public void actualizarLocal() {
        try {
            Local localSeleccionado = getAdministracionLocalDataManager().getAdministracionLocal().getLocal();
            if (localSeleccionado.getLoRuc() == null || localSeleccionado.getLoRuc().trim().length() == 0) {
                this.mensajeError("El ruc es un dato requerido");
            } else {
                localSeleccionado = localFacade.actualizarLocal(localSeleccionado);
                getAdministracionLocalDataManager().getAdministracionLocal().setLocal(localSeleccionado);
                this.obtenerImagenLocal();
                this.mensajeExitoso(" Datos actualizados correctamente");
            }
        } catch (AdministracionLocalException e) {
            LOG.error("Error en la actualizacion de local " + e);
            this.mensajeError(" Error al actualizar el Local");
        }
    }

    public void onTabChange(TabChangeEvent event) {
        LOG.info("ID tab= " + event.getTab().getId());
        if (event.getTab().getId().equals(TAB_ADMINISTRACION_DATOS)) {
            inciaDatosTabAdministracion();
        } else if (event.getTab().getId().equals(TAB_SUCURSALES)) {
            inciaDatosTabSucursales();
        } else if (event.getTab().getId().equals(TAB_EVENTOS)) {
            inciaDatosTabEventos();
        } else if (event.getTab().getId().equals(TAB_FOTOS)) {
            inciaDatosTabFotos();
        } else if (event.getTab().getId().equals(TAB_HISTORIA)) {
            inciaDatosTabHistoria();
        } else if (event.getTab().getId().equals(TAB_HISTORIA)) {
            inciaDatosTabHistoria();
        } else if (event.getTab().getId().equals(TAB_FORMAS_DE_PAGO)) {
            iniciaDatosTabFormasDePago();
        }
    }

    /**
     * metodo que crea una instancia vacia de Ciudad
     */
    public void limpiarCiudad() {
        getAdministracionLocalDataManager().setCiudad(null);
    }

    /**
     * crea instancia nueva de sucursal, pais y ciudad
     */
    public void nuevaSucursal() {
        getAdministracionLocalDataManager().setSucursal(new Sucursal());
        getAdministracionLocalDataManager().setPais(new Pais());
        getAdministracionLocalDataManager().setCiudad(new Ciudad());
    }

    /**
     * metodo que crea una instancia nueva de Evento
     */
    public void nuevoEvento() {
        getAdministracionLocalDataManager().setEvento(new Evento());
    }

    /**
     * metodo que crea un nuevo evento
     */
    public void creaNuevoEvento() {
        try {
            Sucursal sucursal = getAdministracionLocalDataManager().getSucursal();
            if (sucursal == null || sucursal.getSuCodigo() == null) {
                this.mensajeError("Se debe seleccionar una sucursal ");
            } else {
                Evento evento = getAdministracionLocalDataManager().getEvento();
                evento.setSuCodigo(sucursal);
                eventoFacade.crearEvento(evento);
                evento = new Evento();
                evento.setEvPuntos(0);
                getAdministracionLocalDataManager().setEvento(evento);
                consultaEventos();
                this.mensajeExitoso(" Evento creado correctamente");
            }
        } catch (CreaEventoException e) {
            LOG.error(" Error al crear evento " + e);
            this.mensajeError(" Error al crear evento");
        }
    }
    
    /**
     * metodo que edita los datos de un evento
     */
    public void editarEvento() {
        try {
            Sucursal sucursal = getAdministracionLocalDataManager().getSucursal();
            if (sucursal == null || sucursal.getSuCodigo() == null) {
                this.mensajeError("Se debe seleccionar una sucursal ");
            } else {
                Evento evento = getAdministracionLocalDataManager().getEvento();
                eventoFacade.edit(evento);
                consultaEventos();
                this.mensajeExitoso(" Evento editado correctamente");
            }
        } catch (Exception e) {
            LOG.error(" Error al editar evento " + e);
            this.mensajeError(" Error al editar evento");
        }
    }

    /**
     * metodo que crea una nueva sucursal
     */
    public void creaNuevaSucursal() {
        try {
            Sucursal sucursal = getAdministracionLocalDataManager().getSucursal();
            poblarHorario(sucursal);
            sucursal.setLoCodigo(getAdministracionLocalDataManager().getAdministracionLocal().getLocal());
            Usuario usuario = usuarioFacade.recuperaUsuarioPorMail(this.obtenerUsuarioLogeado());
            sucursalFacade.creaYActivaSucursal(sucursal, usuario);
            getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
            getAdministracionLocalDataManager().setSucursal(new Sucursal());
            this.mensajeExitoso(" Sucursal creada correctamente");
        } catch (CreacionSucursalException e) {
            LOG.error(" Error al crear nueva sucursal " + e);
            this.mensajeError(" Error al crear Sucursal");
        }
    }

    /**
     * actualiza los datos de una sucursal
     */
    public void actualizarSucursal() {
        try {
            Sucursal suc = getAdministracionLocalDataManager().getSucursal();
            poblarHorario(suc);
            sucursalFacade.edit(suc);
            getAdministracionLocalDataManager().setSucursal(null);
            getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
            this.mensajeExitoso("Sucursal actualizada correctamente");
        } catch (Exception e) {
            LOG.error(" Error al actualizar sucursal " + e);
            this.mensajeError(" Error al actualizar la Sucursal");
        }
    }

    /*
     * convierte las horas de fecha a String para ser almacenadas en la edicion de sucursales
     */
    private void poblarHorario(Sucursal sucursal) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(sucursal.getHoraDesde());
        int minuto = cal.get(Calendar.MINUTE);
        String min = minuto < 10 ? "0" + minuto : "" + minuto;
        sucursal.setSuHorarioDesde(cal.get(Calendar.HOUR_OF_DAY) + ":" + min);
        cal.setTime(sucursal.getHoraHasta());
        minuto = cal.get(Calendar.MINUTE);
        min = minuto < 10 ? "0" + minuto : "" + minuto;
        sucursal.setSuHorarioHasta(cal.get(Calendar.HOUR_OF_DAY) + ":" + min);
    }

    /**
     * Consulta los eventos relacionados a una sucursal
     */
    public void consultaEventos() {
        Sucursal sucursal = getAdministracionLocalDataManager().getSucursal();
        if (sucursal == null || sucursal.getSuCodigo() == null) {
            getAdministracionLocalDataManager().setListaEventos(new ArrayList<Evento>());
        } else {
            try {
                getAdministracionLocalDataManager().setListaEventos(eventoFacade.recuperaEventosPorSucursal(sucursal));
            } catch (ParametroException ex) {
                this.mensajeError("ERROR recuperar eventos" + ex);
                LOG.info("ERROR recuperar eventos" + ex);
            }
        }
    }

    /**
     * sube imagen de sucursal al FTP
     *
     * @param event
     */
    public void subirFoto(FileUploadEvent event) {
        try {
            getAdministracionLocalDataManager().getArchivo().setNombre(event.getFile().getFileName());
            getAdministracionLocalDataManager().getArchivo().setInputStream(event.getFile().getInputstream());
            getAdministracionLocalDataManager().getArchivo().setCodigo(getAdministracionLocalDataManager().getSucursal().getSuCodigo());
            String ruta = ftpServicio.subeImagenSucAFtp(getAdministracionLocalDataManager().getArchivo());
            LOG.info("ruta = " + ruta);
            getAdministracionLocalDataManager().getSucursal().setSuImagen(ruta);
            getAdministracionLocalDataManager().setInputStreamsImagenTemporal(null);
            consultarReferenciaAImagen();
            if (!getAdministracionLocalDataManager().isReferenciaAImagenes()) {
                getAdministracionLocalDataManager().setInputStreamsImagenTemporal(event.getFile().getInputstream());
            }
        } catch (IOException e) {
            LOG.error("Error al subir foto " + e);
            this.mensajeError("Error al subir Imagen");
        } catch (CrearArchivoException e) {
            LOG.error("Error al subir imagen a FTP " + e);
            this.mensajeError("Error al subir imagen a FTP");
        }
    }

    /**
     * recupera la lista de sucursales actualizadas
     */
    public void actualizarImagen() {
        getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
    }

    /**
     * metodo invocado para actualizar la imagen del evento
     */
    public void actualizarImagenEvento() {
        Sucursal sucursal = getAdministracionLocalDataManager().getSucursal();
        try {
            getAdministracionLocalDataManager().setListaEventos(eventoFacade.recuperaEventosPorSucursal(sucursal));
        } catch (ParametroException ex) {
            LOG.info("ERROR recuperar eventos" + ex);
            this.mensajeError("Error al recuperar eventos de la sucursal");

        }
    }

    /**
     * Sube foto de local tanto de portada como de galeria al FTP
     *
     * @param event
     */
    public void subirFotoLo(FileUploadEvent event) {
        try {
            consultarReferenciaAImagen();
            if (listaComponentesCargaImagenes.contains(getAdministracionLocalDataManager().getCodigoCargaImagen())
                    && !event.getComponent().getId().equals(CARGA_IMAGEN_LOCAL_ID)) {
                subirFotoGaleria(event);
            } else {
                subirFotoLocal(event);
            }
        } catch (IOException e) {
            LOG.error("Error al subir foto " + e);
            this.mensajeError("Error al subir Imagen");
        } catch (CrearArchivoException e) {
            LOG.error("Error al subir imagen a FTP " + e);
            this.mensajeError("Error al subir imagen a FTP");
        }
    }

    /**
     * actualiza los datos del local
     */
    public void actualizarImagenLo() {
        getAdministracionLocalDataManager().getAdministracionLocal().setLocal(administracionLocalDataManager.getAdministracionLocal().getLocal());
    }

    /**
     * Metodo invocado para subir la foto de una evento
     *
     * @param event
     */
    public void subirFotoEvento(FileUploadEvent event) {
        try {
            getAdministracionLocalDataManager().getArchivo().setNombre(event.getFile().getFileName());
            getAdministracionLocalDataManager().getArchivo().setInputStream(event.getFile().getInputstream());
            getAdministracionLocalDataManager().getArchivo().setCodigo(getAdministracionLocalDataManager().getEvento().getEvCodigo());
            String ruta = ftpServicio.subeImagenEventoAFtp(getAdministracionLocalDataManager().getArchivo());
            LOG.info("ruta = " + ruta);
            getAdministracionLocalDataManager().getEvento().setEvFoto(ruta);
            getAdministracionLocalDataManager().setInputStreamsImagenTemporal(null);
            consultarReferenciaAImagen();
            if (!getAdministracionLocalDataManager().isReferenciaAImagenes()) {
                getAdministracionLocalDataManager().setInputStreamsImagenTemporal(event.getFile().getInputstream());
            }
        } catch (IOException e) {
            LOG.error("Error al subir foto " + e);
            this.mensajeError("Error al subir Imagen");
        } catch (CrearArchivoException e) {
            LOG.error("Error al subir imagen a FTP " + e);
            this.mensajeError("Error al subir imagen a FTP");
        }
    }

    /**
     * Metodo invocado al abrir el dialogo para cargar la imagen de galeria para
     * un local
     */
    public void cargarImagenGaleriaLocalTemporal() {
        LOG.info("cargarImagenGaleriaLocalTemporal");
        poblarImagenTemporal(getAdministracionLocalDataManager().getRutaImagenGaleriaCargada());
    }

    /**
     * Metodo invocado al abrir el dialogo para cargar la imagen de la sucursal
     * de un local
     */
    public void cargarImagenSucursalTemporal() {
        LOG.info("cargarImagenSucursalTemporal");
        poblarImagenTemporal(getAdministracionLocalDataManager().getSucursal().getSuImagen());
    }

    /**
     * Metodo invocado al abrir el dialogo para cargar la imagen del evento de
     * una sucursal
     */
    public void cargarImagenEventoTemporal() {
        LOG.info("cargarImagenEventoTemporal");
        poblarImagenTemporal(getAdministracionLocalDataManager().getEvento().getEvFoto());
    }

    /**
     * obtiene las sucursales para ser mostradas como una lista de seleccion
     *
     * @return
     */
    public List<SelectItem> getSelectItemSucursales() {
        List<SelectItem> lista = getSelectItemPorDefecto();
        List<Sucursal> listaSucursal = getAdministracionLocalDataManager().getAdministracionLocal().getListaSucursales();
        for (Sucursal sucursalTmp : listaSucursal) {
            lista.add(new SelectItem(sucursalTmp, sucursalTmp.getSuNombre()));
        }
        return lista;
    }

    /**
     * obtiene las zonas por ciudad para ser mostradas en una lista de seleccion
     *
     * @return
     */
    public List<SelectItem> getSelectItemZona() {
        List<SelectItem> lista = getSelectItemPorDefecto();
        if (getAdministracionLocalDataManager().getCiudad() != null && getAdministracionLocalDataManager().getCiudad().getCiCodigo() != null) {
            List<Zona> listaZona = zonaFacade.recuperaPorCiudad(getAdministracionLocalDataManager().getCiudad());
            for (Zona zonaTmp : listaZona) {
                lista.add(new SelectItem(zonaTmp, zonaTmp.getZoNombre()));
            }
        }
        return lista;
    }

    /**
     * recupera las ciudades por pais para ser mostrados en una lista de
     * seleccion
     *
     * @return
     */
    public List<SelectItem> getSelectItemCiudad() {
        List<SelectItem> lista = getSelectItemPorDefecto();
        if (getAdministracionLocalDataManager().getPais() != null && getAdministracionLocalDataManager().getPais().getPaCodigo() != null) {
            List<Ciudad> listaCiudad = ciudadFacade.recuperaPorPais(getAdministracionLocalDataManager().getPais());
            for (Ciudad ciudadTmp : listaCiudad) {
                lista.add(new SelectItem(ciudadTmp, ciudadTmp.getCiNombre()));
            }
        }
        return lista;
    }

    /*
     *  Obtiene las imagenes de galeria de una local desde el FTP, siempre que el parametro
     * de referencia a imagenes este como FALSO
     */
    private void obtenerListaLocalesImagenes() {
        this.consultarReferenciaAImagen();
        if (!getAdministracionLocalDataManager().isReferenciaAImagenes()) {
            for (int i = 0; i < getAdministracionLocalDataManager().getAdministracionLocal().getListaLocalesImagen().size(); i++) {
                try {
                    String ruta = getAdministracionLocalDataManager().getAdministracionLocal().getListaLocalesImagen().get(i).getLoImRutaFoto();
                    getAdministracionLocalDataManager().getInputStreams()[i] = ftpServicio.obtenerImagenDeFTP(ruta);
                } catch (DescargarArchivoException e) {
                    getAdministracionLocalDataManager().getInputStreams()[i] = null;
                    LOG.error("obtenerListaLocalesImagenes - error al descargar imagen de FTP " + e);
                }
            }
        }
    }

    /*
     * valida si el valor del parametro para referencia de imagenes, 
     * por defecto la referencia es TRUE
     */
    private boolean consultarReferenciaAImagen() {
        boolean referenciaAImagenes = true;
        try {
            referenciaAImagenes = parametrosFacade.recuperaPorNombre(ParametrosEnum.REFERENCIA_A_IMAGENES.getNombre()).getPaValor().equals("SI") ? true : false;
        } catch (ParametroException e) {
            LOG.error("Error al obtener parametro REFERENCIA_A_IMAGENES " + e);
        }
        getAdministracionLocalDataManager().setReferenciaAImagenes(referenciaAImagenes);
        return referenciaAImagenes;
    }

    /*
     * Recuepra la imagen del local desde el FTP siempre que el parametro referencia a imagen este
     * como FALSO
     */
    private void obtenerImagenLocal() {
        consultarReferenciaAImagen();
        if (!getAdministracionLocalDataManager().isReferenciaAImagenes()) {
            try {
                InputStream is = ftpServicio.obtenerImagenDeFTP(getAdministracionLocalDataManager().getAdministracionLocal().getLocal().getLoImagen());
                getAdministracionLocalDataManager().setInputStreamsImagenLocal(is);
            } catch (DescargarArchivoException e) {
                getAdministracionLocalDataManager().setInputStreamsImagenLocal(null);
                LOG.error("Error al descargar imagen de local " + e);
            }
        }
    }

    /*
     * limpia los datos al ingresar al tab de administracion
     */
    private void inciaDatosTabAdministracion() {
        getAdministracionLocalDataManager().setTabActivo(0);
        //Limpia TAB SUCURSALES 
        getAdministracionLocalDataManager().setSucursal(null);
        getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
        //limpia TAB_EVENTOS
        getAdministracionLocalDataManager().setListaEventos(new ArrayList<Evento>());
        //obtiene imagen local
        obtenerImagenLocal();

    }

    /*
     * limpia los datos al ingresar al tab de sucursales
     */
    private void inciaDatosTabSucursales() {
        getAdministracionLocalDataManager().setTabActivo(1);
        //limpia TAB_EVENTOS
        getAdministracionLocalDataManager().setSucursal(null);
        getAdministracionLocalDataManager().setListaEventos(new ArrayList<Evento>());

    }

    /*
     * limpia los datos al ingresar al tab de eventos
     */
    private void inciaDatosTabEventos() {
        getAdministracionLocalDataManager().setTabActivo(2);
        //Limpia TAB SUCURSALES 
        getAdministracionLocalDataManager().setSucursal(null);
        getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
    }

    /*
     * limpia los datos al ingresar al tab de fotos
     */
    private void inciaDatosTabFotos() {
        getAdministracionLocalDataManager().setTabActivo(3);
        //Limpia TAB SUCURSALES 
        getAdministracionLocalDataManager().setSucursal(null);
        getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
        //limpia TAB_EVENTOS
        getAdministracionLocalDataManager().setListaEventos(new ArrayList<Evento>());
        // obtiene fotos dependiendo si el parametro referencia esta activo
        obtenerListaLocalesImagenes();
    }

    /*
     * limpia los datos al ingresar al tab de historia
     */
    private void inciaDatosTabHistoria() {
        getAdministracionLocalDataManager().setTabActivo(4);
        //Limpia TAB SUCURSALES 
        getAdministracionLocalDataManager().setSucursal(null);
        getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
        //limpia TAB_EVENTOS
        getAdministracionLocalDataManager().setListaEventos(new ArrayList<Evento>());
    }

    private void iniciaDatosTabFormasDePago() {
        getAdministracionLocalDataManager().setTabActivo(5);
        getAdministracionLocalDataManager().setSucursal(null);
        getAdministracionLocalDataManager().getAdministracionLocal().setListaSucursales(sucursalFacade.recuperaPorUsuario(this.obtenerUsuarioLogeado()));
        getAdministracionLocalDataManager().setListaEventos(new ArrayList<Evento>());
        getAdministracionLocalDataManager().setListaTarjetas(formasDePagoFacade.recuperaTarjetasAnadidas(getAdministracionLocalDataManager().getAdministracionLocal().getLocal()));
    }

    /*
     * Metodo que pone en la variable en sesion la imagen a editar, siempre que este
     * el parametro de referencia a imagen como NO
     */
    private void poblarImagenTemporal(String ruta) {
        try {
            LOG.info("poblarImagenTemporal");
            getAdministracionLocalDataManager().setInputStreamsImagenTemporal(null);
            consultarReferenciaAImagen();
            if (!getAdministracionLocalDataManager().isReferenciaAImagenes()) {
                InputStream is = ftpServicio.obtenerImagenDeFTP(ruta);
                getAdministracionLocalDataManager().setInputStreamsImagenTemporal(is);
            }
        } catch (DescargarArchivoException e) {
            LOG.error("Error al descargar imagen desde FTP " + e);
        }
    }

    /*
     * sube la imagen de galeria a la carpeta FTP
     */
    private void subirFotoGaleria(FileUploadEvent event) throws IOException, CrearArchivoException {
        getAdministracionLocalDataManager().getArchivo().setNombre(event.getFile().getFileName());
        getAdministracionLocalDataManager().getArchivo().setInputStream(event.getFile().getInputstream());
        getAdministracionLocalDataManager().getArchivo().setCodigo(getAdministracionLocalDataManager().getAdministracionLocal().getLocal().getLoCodigo());
        getAdministracionLocalDataManager().getArchivo().setOrden(CargaImagenesLocalEnum.valueOf(getAdministracionLocalDataManager().getCodigoCargaImagen().toUpperCase()).getOrden());
        String ruta = ftpServicio.subeImagenesLocAFtp(getAdministracionLocalDataManager().getArchivo());
        LOG.info("ruta = " + ruta);
        getAdministracionLocalDataManager().setRutaImagenGaleriaCargada(ruta);
        getAdministracionLocalDataManager().getAdministracionLocal().setListaLocalesImagen(localesImagenFacade.recuperaPorLocal(getAdministracionLocalDataManager().getAdministracionLocal().getLocal()));

        // vista de imagen por archivo fisico
        getAdministracionLocalDataManager().setInputStreamsImagenTemporal(null);
        if (!getAdministracionLocalDataManager().isReferenciaAImagenes()) {
            getAdministracionLocalDataManager().setInputStreamsImagenTemporal(event.getFile().getInputstream());
            obtenerListaLocalesImagenes();
        }
    }

    /*
     * sube la imagen del local a la carpeta FTP
     */
    private void subirFotoLocal(FileUploadEvent event) throws IOException, CrearArchivoException {
        getAdministracionLocalDataManager().getArchivo().setNombre(event.getFile().getFileName());
        getAdministracionLocalDataManager().getArchivo().setInputStream(event.getFile().getInputstream());
        getAdministracionLocalDataManager().getArchivo().setCodigo(getAdministracionLocalDataManager().getAdministracionLocal().getLocal().getLoCodigo());
        String ruta = ftpServicio.subeImagenLocAFtp(getAdministracionLocalDataManager().getArchivo());
        LOG.info("ruta = " + ruta);
        getAdministracionLocalDataManager().getAdministracionLocal().getLocal().setLoImagen(ruta);

        // vista de imagen por archivo fisico
        getAdministracionLocalDataManager().setInputStreamsImagenLocal(null);
        if (!getAdministracionLocalDataManager().isReferenciaAImagenes()) {
            getAdministracionLocalDataManager().setInputStreamsImagenLocal(event.getFile().getInputstream());
        }
    }

    public AdministracionLocalDataManager getAdministracionLocalDataManager() {
        return administracionLocalDataManager;
    }

    public void setAdministracionLocalDataManager(AdministracionLocalDataManager administracionLocalDataManager) {
        this.administracionLocalDataManager = administracionLocalDataManager;
    }

    public void crearFormaDePago() {

        try {
            FormasDePago formaPagoSeleccionada = getAdministracionLocalDataManager().getFormaDePagoSeleccionada();
            String estado = getAdministracionLocalDataManager().getEstadoFormaPago();
            localesFormasDePagoFacade.crearFormaPagoParaLocal(getAdministracionLocalDataManager().getAdministracionLocal().getLocal(), formaPagoSeleccionada, estado);
            getAdministracionLocalDataManager().setListaTarjetas(formasDePagoFacade.recuperaTarjetasAnadidas(getAdministracionLocalDataManager().getAdministracionLocal().getLocal()));
        } catch (CrearFormaDePagoException ex) {
            this.mensajeError(ex.getMessage());
        }
    }

    /**
     * convierte la hora de atencion de las sucursales de string a fecha, en la edicion de sucursales
     */
    public void poblarFechas() {
        Sucursal sucursal = getAdministracionLocalDataManager().getSucursal();
        String horaDesde = sucursal.getSuHorarioDesde();
        String horaHasta = sucursal.getSuHorarioHasta();
        String[] horDesd = horaDesde.split(":");
        String[] horHasta = horaHasta.split(":");
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(horDesd[0]));
        cal.set(Calendar.MINUTE, Integer.parseInt(horDesd[1]));
        sucursal.setHoraDesde(cal.getTime());
        cal.set(Calendar.HOUR_OF_DAY, Integer.parseInt(horHasta[0]));
        cal.set(Calendar.MINUTE, Integer.parseInt(horHasta[1]));
        sucursal.setHoraHasta(cal.getTime());
       getAdministracionLocalDataManager().setSucursal(sucursal);
    }
}
